{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trust Scores applied to Iris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to know when a machine learning classifier's predictions can be trusted. Relying on the classifier's (uncalibrated) prediction probabilities is not optimal and can be improved upon. *Trust scores* measure the agreement between the classifier and a modified nearest neighbor classifier on the test set. The trust score is the ratio between the distance of the test instance to the nearest class different from the predicted class and the distance to the predicted class. Higher scores correspond to more trustworthy predictions. A score of 1 would mean that the distance to the predicted class is the same as to another class.\n",
    "\n",
    "The original paper on which the algorithm is based is called [To Trust Or Not To Trust A Classifier](https://arxiv.org/abs/1805.11783). Our implementation borrows heavily from https://github.com/google/TrustScore, as does the example notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "%matplotlib inline\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from alibi.confidence import TrustScore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and prepare Iris dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = load_iris()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scale data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset.data = (dataset.data - dataset.data.mean(axis=0)) / dataset.data.std(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define training and test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = 140\n",
    "X_train,y_train = dataset.data[:idx,:], dataset.target[:idx]\n",
    "X_test, y_test = dataset.data[idx+1:,:], dataset.target[idx+1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit model and make predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted class: [2 2 2 2 2 2 2 2 2]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "clf = LogisticRegression(solver='liblinear', multi_class='auto')\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)\n",
    "print(f'Predicted class: {y_pred}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Trust Score Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialise Trust Scores and fit on training data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The trust score algorithm builds [k-d trees](https://en.wikipedia.org/wiki/K-d_tree) for each class. The distance of the test instance to the $k$th nearest neighbor of each tree (or the average distance to the $k$th neighbor) can then be used to calculate the trust score. We can optionally filter out outliers in the training data before building the trees. The example below uses the *distance_knn* (`filter_type`) method to filter out the 5% (`alpha`) instances of each class with the highest distance to its 10th nearest neighbor (`k_filter`) in that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = TrustScore(k_filter=10,  # nb of neighbors used for kNN distance or probability to filter out outliers\n",
    "                alpha=.05,  # target fraction of instances to filter out\n",
    "                filter_type='distance_knn',  # filter method: None, 'distance_knn' or 'probability_knn'\n",
    "                leaf_size=40,  # affects speed and memory to build KDTrees, memory scales with n_samples / leaf_size\n",
    "                metric='euclidean',  # distance metric used for the KDTrees\n",
    "                dist_filter_type='point')  # 'point' uses distance to k-nearest point\n",
    "                                           # 'mean' uses average distance from the 1st to the kth nearest point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts.fit(X_train, y_train, classes=3)  # classes = nb of prediction classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Trust Scores on test data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the trust score is the ratio between the distance of the test instance to the nearest class different from the predicted class and the distance to the predicted class, higher scores correspond to more trustworthy predictions. A score of 1 would mean that the distance to the predicted class is the same as to another class. The `score` method returns arrays with both the trust scores and the class labels of the closest not predicted class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trust scores: [2.574271277538439 2.1630334957870114 3.1629405367742223\n",
      " 2.7258494544157927 2.541748027539072 1.402878283257114 1.941073062524019\n",
      " 2.0601725424359296 2.1781121494573514]\n",
      "\n",
      "Closest not predicted class: [1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "score, closest_class = ts.score(X_test, \n",
    "                                y_pred, k=2,  # kth nearest neighbor used \n",
    "                                              # to compute distances for each class\n",
    "                                dist_type='point')  # 'point' or 'mean' distance option\n",
    "print(f'Trust scores: {score}')\n",
    "print(f'\\nClosest not predicted class: {closest_class}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison of Trust Scores with model prediction probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare the prediction probabilities from the classifier with the trust scores for each prediction. The first use case checks whether trust scores are better than the model's prediction probabilities at identifying correctly classified examples, while the second use case does the same for incorrectly classified instances. \n",
    "\n",
    "First we need to set up a couple of helper functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Define a function that handles model training and predictions for a simple logistic regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_lr(X_train, y_train, X_test):\n",
    "    clf = LogisticRegression(solver='liblinear', multi_class='auto')\n",
    "    clf.fit(X_train, y_train)\n",
    "    y_pred = clf.predict(X_test)\n",
    "    y_pred_proba = clf.predict_proba(X_test)\n",
    "    probas = y_pred_proba[range(len(y_pred)), y_pred]  # probabilities of predicted class\n",
    "    return y_pred, probas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Define the function that generates the precision plots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_precision_curve(plot_title, \n",
    "                         percentiles, \n",
    "                         labels, \n",
    "                         final_tp, \n",
    "                         final_stderr, \n",
    "                         final_misclassification,\n",
    "                         colors = ['blue', 'darkorange', 'brown', 'red', 'purple']):\n",
    "    \n",
    "    plt.title(plot_title, fontsize=18)\n",
    "    colors = colors + list(cm.rainbow(np.linspace(0, 1, len(final_tp))))\n",
    "    plt.xlabel(\"Percentile\", fontsize=14)\n",
    "    plt.ylabel(\"Precision\", fontsize=14)\n",
    "    \n",
    "    for i, label in enumerate(labels):\n",
    "        ls = \"--\" if (\"Model\" in label) else \"-\"\n",
    "        plt.plot(percentiles, final_tp[i], ls, c=colors[i], label=label)\n",
    "        plt.fill_between(percentiles, \n",
    "                         final_tp[i] - final_stderr[i],\n",
    "                         final_tp[i] + final_stderr[i],\n",
    "                         color=colors[i],\n",
    "                         alpha=.1)\n",
    "    \n",
    "    if 0. in percentiles:\n",
    "        plt.legend(loc=\"lower right\", fontsize=14)\n",
    "    else:\n",
    "        plt.legend(loc=\"upper left\", fontsize=14)\n",
    "    model_acc = 100 * (1 - final_misclassification)\n",
    "    plt.axvline(x=model_acc, linestyle=\"dotted\", color=\"black\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The function below trains the model on a number of folds, makes predictions, calculates the trust scores, and generates the precision curves to compare the trust scores with the model prediction probabilities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_precision_plt(X, y, nfolds, percentiles, run_model, test_size=.5, \n",
    "                      plt_title=\"\", plt_names=[], predict_correct=True, classes=3):\n",
    "    \n",
    "    def stderr(L):\n",
    "        return np.std(L) / np.sqrt(len(L))\n",
    "    \n",
    "    all_tp = [[[] for p in percentiles] for _ in plt_names]\n",
    "    misclassifications = []\n",
    "    mult = 1 if predict_correct else -1\n",
    "    \n",
    "    folds = StratifiedShuffleSplit(n_splits=nfolds, test_size=test_size, random_state=0)\n",
    "    for train_idx, test_idx in folds.split(X, y):\n",
    "        # create train and test folds, train model and make predictions\n",
    "        X_train, y_train = X[train_idx, :], y[train_idx]\n",
    "        X_test, y_test = X[test_idx, :], y[test_idx]\n",
    "        y_pred, probas = run_model(X_train, y_train, X_test)\n",
    "        # target points are the correctly classified points\n",
    "        target_points = np.where(y_pred == y_test)[0] if predict_correct else np.where(y_pred != y_test)[0]\n",
    "        final_curves = [probas]\n",
    "        # calculate trust scores\n",
    "        ts = TrustScore()\n",
    "        ts.fit(X_train, y_train, classes=classes)\n",
    "        scores, _ = ts.score(X_test, y_pred)\n",
    "        final_curves.append(scores)  # contains prediction probabilities and trust scores\n",
    "        # check where prediction probabilities and trust scores are above a certain percentage level\n",
    "        for p, perc in enumerate(percentiles):\n",
    "            high_proba = [np.where(mult * curve >= np.percentile(mult * curve, perc))[0] for curve in final_curves]\n",
    "            if 0 in map(len, high_proba):\n",
    "                continue\n",
    "            # calculate fraction of values above percentage level that are correctly (or incorrectly) classified\n",
    "            tp = [len(np.intersect1d(hp, target_points)) / (1. * len(hp)) for hp in high_proba]\n",
    "            for i in range(len(plt_names)):\n",
    "                all_tp[i][p].append(tp[i])  # for each percentile, store fraction of values above cutoff value\n",
    "        misclassifications.append(len(target_points) / (1. * len(X_test)))\n",
    "    \n",
    "    # average over folds for each percentile\n",
    "    final_tp = [[] for _ in plt_names]\n",
    "    final_stderr = [[] for _ in plt_names]\n",
    "    for p, perc in enumerate(percentiles):\n",
    "        for i in range(len(plt_names)):\n",
    "            final_tp[i].append(np.mean(all_tp[i][p]))\n",
    "            final_stderr[i].append(stderr(all_tp[i][p]))\n",
    "\n",
    "    for i in range(len(all_tp)):\n",
    "        final_tp[i] = np.array(final_tp[i])\n",
    "        final_stderr[i] = np.array(final_stderr[i])\n",
    "\n",
    "    final_misclassification = np.mean(misclassifications)\n",
    "    \n",
    "    # create plot\n",
    "    plot_precision_curve(plt_title, percentiles, plt_names, final_tp, final_stderr, final_misclassification)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detect correctly classified examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The x-axis on the plot below shows the percentiles for the model prediction probabilities of the predicted class for each instance and for the trust scores. The y-axis represents the precision for each percentile. For each percentile level, we take the test examples whose trust score is above that percentile level and plot the percentage of those points that were correctly classified by the classifier. We do the same with the classifier's own model confidence (i.e. softmax probabilities). For example, at percentile level 80, we take the top 20% scoring test examples based on the trust score and plot the percentage of those points that were correctly classified. We also plot the top 20% scoring test examples based on model probabilities and plot the percentage of those that were correctly classified. The vertical dotted line is the error of the logistic regression classifier. The plots are an average over 10 folds of the dataset with 50% of the data kept for the test set.\n",
    "\n",
    "The *Trust Score* and *Model Confidence* curves then show that the model precision is typically higher when using the trust scores to rank the predictions compared to the model prediction probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = dataset.data\n",
    "y = dataset.target\n",
    "percentiles = [0 + 0.5 * i for i in range(200)]\n",
    "nfolds = 10\n",
    "plt_names = ['Model Confidence', 'Trust Score']\n",
    "plt_title = 'Iris -- Logistic Regression -- Predict Correct'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaUAAAEeCAYAAAAq3woYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXmYFNXVuN8zw8AMDMO+CciooAaVaETcEkHFXaOiiXuCmuCnQaPfD6PGHRf0kySaqImaoKKJqKgoinvE3QAqKmhYRFCQfRtm7enu8/vjVE3X9PTMdM/09Gz3fZ56arm3qm5XV9Wpc+6554iq4nA4HA5HSyCruRvgcDgcDoePE0oOh8PhaDE4oeRwOByOFoMTSg6Hw+FoMTih5HA4HI4WgxNKDofD4WgxtCqhJCI3iYiKSGFzt6WlISKF3rW5Kc3HfURE3LiBDOLu86Yl0T3t7vOWQ7MJJREZ4z14k5qrDekk8CIZ2dxtSRURGS8il2fwfCu9a+VPIRFZJSL/EJGdM9UOR2YIPBv+FBWRLSLyuoic2NztayyNeX5E5EgReUpEvhORChHZISIfi8htIjIo3W1tDrx3/U0i0j2Z+q1KUwJuBfKAVc3dkBbIKuza3NqAfccDtT1Uv/aOm25WA+d502XAe8D5wEci0qsJzteaaKv3+Q3Y/30B8DfgR8BsETm7WVtlNOY+H0/tz09CRCRLRB4C3gBGAf8CfgNcBSz0lj9pYHtaGmOAG4GkhFKHJm1KmhCRrqq6Q1XDQLi529MSUQvNUd4Ex60EKtN9XGC7qj4eWP+biKwHrsAe8j80wTmTwr/fmuv8bfg+f1lVF/grIvIMsAC4FnspJyQT/0cT3ue1cRPwK+AJYLyqhoKFIvL/sBd5WhCRHCBbVRO+I5r7ng/SojSlYL+IiJzhqbFlwF+88hq2dhHpKSJ/EpGvRaRcRDZ7+13ZTD+jXkRkhIg857W1XES+FJHfiUh2grqjReRDESkTkXUico+I7BXff1Rbn5KI/EJE5onINhEpEZEVIvJPEenjla8ERgND4kwsY7zyhLZ2EekvIn/2jlchIhs8c8xRjbg0b3rzYQnO101E7hSR5d75NorIEyKya4K6hSLyjIgUedPzIrKLZzacG1dXvd94pIi8JyLFwOxUzysiud79uURESr3r/YWI3BVX7wQReVtENnn/6bci8qyI7B6ok7BPyftdj4nIeq8tX4vI7SLSOa6ev/8eXvlqr/5nInJ8Pf9BxlDVj4HNwFB/m4jM9f6nXUVkpohsAYoC5SIiF3vPeKmIFIvIWyJyePzxvf/kLhH53rvW80Tk6ERtaeh9Xt/zU8u5+gJXYprwBfECybs221T1irj9Uv3/9xKRP4rIauyD9SCvPC33vFe3o9i7a6H3f2wXkQUiMtG/rsSE6zeB63NTbdenpWpKp2Amnb9ian5RHXWfBg7z6n2OqeA/wFTGu2rfrXkQ63N6G/squw9YB5wE3An8EDgnUPfHwGvAVuAOYBvwc+DQJM91HvAo8C5mOikDBgPHA32BjZjZYQrQG9NSfL6q47iFwPtAP2A69rXbBbvpxwKvJ9O+BOzmzbfEna8b8AGwMzANWAwMAC4B/iMiI1V1lVe3F/Z7+2H3xFfAT4C3vDYmYiRwGvAQdr1SPi/2X16AXY8/Ys/WMOCIwPFGAy8Ai7Brvg3YCbtmQ4GltV0YERkCzAO6AfcDy7B7/BrgUBE50tOwgjyK3WdTgY7Yfz1LRHZX1ZW1nStTiEhvoAf2DATJx56R9zEtqm+g7DHgLGAm8DDQCXtmXheRcar6QqDuE9i7ZDbwKnZ/PQt8k2T7Cqn/Pk/5+QFOAHKB6bVpLgna0pD//5/YM/8HQIG1gbJG3/Mi0hG7rmOw99TjmPDbBxgH3As8ABQAp2LXZ5N3qs9r/bGq2iyT90MUmBTYVuhtqwR+kGCfm7zyQm+9m7d+f3P9jgRtG1lPvfcx08yIwDYBnvL2PzKwfZ73J+8a2JbjHUOBmxJcu+C2ZzGB3qGeNs0FVtZS9giedTCwbY53rmMS1M9K4lqtxB7a3t5UCJyLCaPK4LXx6t+DPVw/jNs+xPt9jwS2/Z/XtnPi6vrb58ZtV28am6CdqZx3CzCnnt/9R+9cfZO8lwoD2/7pbTs+ru5d3vYLE+z/IiCB7Qd426c007NxpPd/98c+JN+Lb493Lypwa4LjnOqVTYjb3gETGN/4vxc42qv7SFzdU/z/PF33eV3PTy3XwxcS41LYpyH//1wSPPtpvOd/5x3n9nquT437ua6pRZnvArykqnV9afiUARXAgfGmjpaIp7YfArygqlVfCmr/3G3e6qle3X7YS+R5VV0RqFuJ3TjJsB3oDJwgItL4X2DmUuBY4BVVfTW+XFWjSR5qT0xT24i9TB7DTDknB6+N1+5zgHeANSLS25+AEuAj7AXkcxL2RfhE3Pmm1tGWz1T1jeCGBpx3O7CXiOxdx3m2e/PTRCRpK4WIZAE/BT5V1TlxxVOAKN59E8c93r0FgKrOB4pJYB7NEG9g//daTBPaDxPU1yeom+j/OhfYgWl7wf+jO6YNFRL7bad482rWElWdBSypr6FpvM8TUeDN67IABdvS0P//bq2pPfmk454/B7PiTI4/eGOuT0s139VqxgiiqiExV8x7MHvll8C/gVmq+mZd+4r13/SJ21ymqts9FTbeE2ejqkaSa36t7OLNFyco+wq7uXaNq5voAar3ofK4HfsinQVsFpG3gZeBJ7XhnZpDMc3u0wbu77MS83gC+3K+GBhBzQ7+PkAv7GHYWMuxgg/ALsC8+IdCVTeIyLZa9k90v6V63ssxwfqFiKzAzIWzgdmBttwLnIyZX+4UkfeAV4AnVLW2c/htySfBfaOqW0RkLbH7JsiKBNs2e7+rVprw2fgNdq2jmOnyK1UtS1Bvo6om+q9+AHQF1tdxjn7eOXb1zpPov/0K2KOetqbrPk+EL4y6Jlm/of9/Xe/RdNzzw4CFmqQJMllaqlAqTbaiqv5NRJ7H7LSjgdOBiSLypKqeWceug6lpW34U8/y6B/hlXNku2Iu01aCqy0RkOGY2ORK7Pg8BN4vIYar6dTM2ryT4pSYiM7EvsSdFZLiq+vZvX8N7A+t3awoS3W8pnVdVn/e09eOx6zwWuBB4V0TGqmpIVTeLyAFYH9dR2AfDn7D/43hV/bDRv6Q6tQmK+rTmpno25mnA+64Oanv+BXtZ1uVCviiJ4zc3fhv3A55rwvPU9R5t9D3fVLRUoZQS3gvs78Dfva+8x4CzROQPnskiEeuwF0OQ7735/2GddvH1G4v/oO+VoGxPzBvS/7pd6c0TfdHV95VXhapWYLbxOQBi3lcvAf+LfbmC2XuTZblXf98U9qkXVS0XkSswTfdmYIJXtBH7qi6INzfUwkpgqIhkBbUlz3Sa1DiJBp4XVd2C3TePe6aQOzC7+8mYQw6eRjHXmxCREcDHwHXYh1VtbdlBgvtGRHpgHdELk/tZSdEcz0YyLAN2Bz5S1eJ66q7Anqfdqalh/CCJc6Vyn6caCeIlrK/4PBG5zXtG6yJT/3+q9/xSYE8R6VTPb0jp+rTUPqWkEJHO8e6Q3kPv90n0rG1fVS1X1Tfipi+9si8TlDVaRVXVDZhny0nBvgfvBXaNt/qcV3cd1nl7ctAVU2y8wW+TOZ9nC47HH5AXvDbFQI9k+p28F+/LwHEiMjbBORvcd6Wqb2H27PEisou3LYp18o4SkdMT7ecJHJ/Z2EN6Vly1lCKHpHJeEcmWuNHqXl+Ob/rp6dVL9H/8F+sbretejWK/az8ROTau+GrsOU7bF3dzPBtJMh37rVMSFXr9sD7Pe/Mr4+qcQhIfdSne50k/P96xN2B9XYXYh3THBMcvEJE/efUz8v834Fn7J+Y9eV2CevHXB+q4x4O0dk1pd+BtEXkOU4m3Yl9BF2NaybvN0KYLEtw4AB+r6suYQHkbM+v4LuEnAscA/4rrC5uEuZ1+ICL3Yx3lP8fce6H+L5DXvH6Ud4HvME1hvLffY4F6H3ltuFdEPsDMPv/2Hp5ETMSE68si8ij2pZ8HHIhpKlfV0666uAX7zddh5i8wt+BDgadE5CmvvSHMI+h47/zjvbp3Yuadh0VkFPbS/wnmYLKJ1L7akj1vV2CtiLyACaINmEnrYuye9MeAPCQWOuY1YhE4zvD2n15PW36PaS+zvHthOWb+OwMT5I/WsW+bQFVnisjDmHn+R5h34SZgEHAw1g+0q1f3VRGZDfzSc1p4BXMJvwh7V9TlkOKT7H2e6vMD5pE2ABtA+2MRmYH9px0x7exn2L3mu5ln6v9P5Vm7B3Msus4zS7+GaYB7YYLfF+YfefM7ReSfXp1FqprY1JqMi15TTNTtEn5TLfvcRHWX8F6YTX4hpnaWYX/W3cCADP8ev221TX8L1P0h5nywBfMe/Aoz82QnOO4R3p9ajgmwe7CHQoHf1XXtMEeC1739QpjX0xzg8LhzdAb+gXUgR7zjjPHKHiHOVdbbPhAbB/Std+z13k15ZBLXaqV3U9ZW/iHmGr5bXBuvB77w/ucd3nV7CDgwbv9dMHf4HVin8vPetk3EuW2TwG04wbWp87zYi2QK5sK/2ftPV2LjPIYFjjUOG6e02quzEftAOa2u+zzudz2GCb0QZqK6HeiczP6Baz+3mZ6NOodLeHXnUo97NRaq6F3vvy33ftOzwBlx9fIw9+t13n83D+vEr3FPN+Y+p47nJ4nfOxYz7a72jr8De/HfQtw7LB3/f7ru+UDdXEyQLfb+i23AfOCSuHq/89pbSR3veFWt8ul3tCJE5DRs8OBZqjqjudvTGhAbVLsJeEBV/6e52+NwOBLTqvuU2jpi5MZty8GcFMJ4neWO6ohIosCaV3vzhkabcDgcGaC19ym1dToBqzw77BLMXHkGNp7nTjVnCEdN5ojIKsypIwtzhz8R6x+Y1ZwNczgcdePMdy0Yz739IWzcywBsHMES4EFVvb8529aSEYuw/Ausny0Ps9c/C9ysLSQSssPhSIwTSg6Hw+FoMbRZ813v3r21sLCwuZvhcDgcrYqPP/54k6rGh5nKGG1WKBUWFrJgQTIRTVoX3333HQCDBw9u5pY4HI62iNcf22y0WaHUVjnvvPMAmDt3bvM2xOFwOJoAJ5RaGdddVyOih8PhcLQZnFBqZYwdWyMMl8PhcLQZ3ODZVsaKFStYsSJRmhyHw+Fo/ThNqZVxwQUXAK5PyeFwtE0yJpREZBo2qn6DqtaI0OuFOr8Hi0RbCoxX1U+8sl8SC49+q6q2+YjItXHzzTc3dxMcDoejycikpvQIlg66thD9x2HpdYdhUbD/ChzohZ2/ERiJRZf9WEReUNWtTd7iFsjo0aObuwkOh8PRZGRMKKnqO1666No4GZiuFmLiIxHpLiIDsBQXr6sl3UJEXgeOBZ5o2ha3TJYsWQLAHnsknXy2+Vn2LGxIZ2JURyK++w6+9hLcDxgA/i2SyNI7aDAM3Q3CEXgvQdaxwkKbKkLw4Qc1y3fbDQYPhtJSmDevZvmw3WHgTrBjB3z8cc3yH/wA+vWDrdvgswS3xt57Q+/esGkzLPqiZvkP94Ue3WH9evjqq5rlP9ofCrrC99/D0qU1y0eNgs6dq1+zIAcfDJ06wcqVNsXz459Ah2xY/jWs/q5m+ZgxNl+yFNZ+X70sOxt+8hNb/vJL2BCXdaljRzjkEFv+4gvYvLl6eV4eHHigLX+6ELZvq16enw8jDx8EIybQGslomCFPKL1Yi/nuReAOVX3PW38TS6I1BshV1Vu97dcDZao6NcExJuCl0d555533X7WqWceANQljvLu9RfcpVeyASMiW134Es070ChqclNbhUdfTqhqoIODn/owlhQ/QxOUiVP3dCcsDLlZNWq7edWlgebVrmqny4LVtYHm45350vCDB10ASiMjHqjqyQTungTbl6KCqDwIPAowcObJNBvW7/fbbm7sJdVNRBMVrIKsjRCPw7u+gcz84833o0rf+/R11svZ7KC6GrOzq2z//IovTzujCHbeWccn/hJuncY4WQ4eOrffV3pJavgYIxs4Z5G1bg2lLwe1zM9aqFsYhvl7fUqgshdKNsfUlM2Dh/YBCtBJK1sFhf4Cug6BDp2ZrZltAFUoqoUuP2JeyzwfzzOxz8ml5dO3VPO1zONJBSxJKLwATvVz1BwLbVXWtiLwK3C4iPbx6RwPXNFcjm5tFiyyt/d5717CAZp5IJexYA9k5Zo8oWQcf3QJdd4bee1md7sNgt5Mgu2PztrUNUFYGn3wCHTpYf0iPHtY/kZMDV1wBxxxjfUkOR2smky7hT2AaT28RWY151OUAqOrfgDmYO/hyzCX8fK9si4jcguV9B5jsOz20RyZOnAg0U5+SRqFkg2lAYPONn0K55wi59GmIhuGYf0DBENsWLoOOXWt+2jtSZtEiuPdeeO+96ttHjoTnn4chQ0xbcjhaM5n0vjurnnIFflNL2TRgWlO0q7Vx1113Nd/JyzZDqAiyPTPcqtfgjYur1zngKsjrC6FiW49GoEt+ZtvZRhk0CKZMMY+y0lLYutVMer08c52qaVEOR2vG3cKtjAMOOCDzJy3bYlpR+daY1lNRBB/cBL32giP+DIiZ6LoONm0pf5C3s0CH3My3uQVSXm4uzD5ZWWZ6E7Hljh1tHiwPrm/cCLvsArvuWvPYqlbXCSVHa8fdwq2MhQttUMe+++6bmRNGKqFsI2R1gE//Al/Psu3hchNSx0yDnnvG6od2QJcBkNM5M+1rRWzdCuGwCSKAaNQ0HjChEo0mdk/26x56KFxwAVx9dc3ycNjG1TgrqaO144RSK+Pyyy8HMtin5PcfrXkPPrsfBv4Y8gfatoE/hj4/NAEFgIJkQ0dnrosnGrWBpF26VBccvoCqj5UroaQEdtrJ5iLm5OBrUhUV5vjgcLR2nFBqZdx9992ZPeHXs2HlK/DNy6YRHfdYdU+6UDHk5McGzuR0qT6y0QGY6Q4arsksXmzzYcOgZ08TRuXlpiGBjfLPd98CjjaAE0qtjIyZ7Xze+z3s+A669Icxd1cXSNGwmfXyBzi7UQI0EC2gqAhCITPhgQmVgoLkL9vixaYZDRsG3bq5viNH28Xd2q2M+fPNMz4jDg+REBStgn0vgVFeR0ZlGeDFdYmGzbHBCaQaRKNmcvM1mXXr4KSTTDj59O4Nxx0Hd9xh67NnWz0wM9+++5rHXUGBCaWhQ00jyo6L5uBwtCWcUGplXHnllUCG+pS2/Bc0YgNgwcYcZXeEjgW2LmLmOkcNwmGbfJPa0KHw1lvw3HPmZVdZCf/9b2xckSpce23N4Junnmpjk8aNM6cI31vP4WirOKHUyrj33nszd7JNXkdGj2E2cDYaga79XHSGJKisrLmtf3+4+OKa233eDUTr3rIFFi6MjUE6+WTrQ8p13vWONo4TSq2MJg8vVL41FqFh/QKb5/WyGHed+ziBlCTl5dXHGF16qaVLOO+8xPVFrK/Ip1s3G5MUJBJxQsnR9nFCqZXxwQeW3KZJArNGI1C6yQa7isD2lTbmKK8vFOzs7EYpUFYWc0YoKYFZsywMUGOIRpN3IXc4WitOKLUyfv/73wNN1KcUKgY05t69/WvotpuFFXICKSXKy80pAeCzz0yg7Ldf44/rvO4cbR13i7cyHnjggfQdTBXCpTG/5fLNsZBAqrBtOQwb51JOpEg4bELIl+NeEA5+8AMbQBuU71lZ1cMM1Sf7nVBytHXcLd7KSGsa9HAZFH1rURjA5lm+zWktVJZAwa6Q5WxGiYhEbBKpblarrKweLui22yy1eEGBOTv4GlQ4bB510ahFZCgpqX78+ACr2dnOHdzR9nFCqZXx9ttvAzB69OjGH6yiyBwXOnhvyfWfwFu/tfFHfjrz7rvGBFU7JxibrqLConVHvSFbHTpY7DkwQXXcceYxd+WVMHGiOTmA1fEFWE5OTED5x48GUntXVMRi4/n7OhxtHfe2aWXceOONQBr6lDRqaSiC44y+fBRK10PhsbbeqRv03jemSbVjysvh229j66omUHxNJhKJuYGXlMA338SEyDVeSsodO+o2v8VHBe/QwQbROhztCSeUWhnTpqUprVS4HAugKrH1la/CLifA4X+K1QsVO00Ji8SQnV1dswkSNK0tXWrzYIqJaNSZ3xyOZHBvm1bGromS6aRCuAJKN0I0VF3YrH7b0k7s9tPYNo1anXbueReNwvbttQukeFassHlwnFE47MYYORzJ4IRSK+ONN94AYOzYscnv5HeERMOwY7Xn7tUBNnwKRSutbMnTkNvD0lH4RMOQ5QbLlpebYMpKMvj5N9/YPCiUIhHo2jX9bXM42hpOKLUybr31ViAFobRjtUVjAGwMUgdz+y7fArN/bhqTz17nQ3bAjUwj7Ta23bZt5mgA1QfCJsPQoXDOOdA5kOcwEnGOCg5HMjih1Mp47LHHkq8cqYRQCXRK8Im+Yo4JpOP/Cd28T/r8QRbVwU/sFwm1S01J1VKP+/0/Ismb7gBOOMGm+GO6MUYOR/1kNBubiBwrIktEZLmI1EjqLCJDRORNEflcROaKyKBA2f+JyGIR+UpE/izSPjs6Bg8ezODBg5OrHC6rvT9o+SyL/j1oNBQMsSkr2wbTdsgzDSm3J+Sk8DZuI4TDJkRyc21KVcPZvt3mFRVm+vMT/Dmh5HDUT8aEkohkA/cBxwHDgbNEZHhctanAdFUdAUwGpnj7HgIcCowA9gYOANIwUKf18corr/DKK68kV7lie80Aqqpm0lv7EQw7pbrQUrWssV36Q5d+NrXDAKyJInzHowpffFFz+5YtMHw4TJtmx+nSxaZevZxQcjiSIZOPyShguaquABCRGcDJwJeBOsOB//WW3wJmecsK5AIdAQFygPUZaHOL4w4vI9yxx3pjiSKVEPE+xbM6xvqEohHrSwqa7oq+hdmnQ/EaW9/tlOoHj4a8dObtUgmtoqKifqeGO+6AJ56Azz+39ZkzLT+Snw9pwAAz+fXr17RtdTjaGpkUSgOB7wLrq4ED4+p8BowD7gFOBbqKSC9V/VBE3gLWYkLpXlX9Kv4EIjIBmACw8847p/8XtABmzJhRfUNFEZStB+mAye6gQFGL9A2gYXj9f2zc0f7/D7oV2hQkHIK8Pk3V9FZDaWndWs3q1fDQQ3DQQbZeXg5TpphzBEDfvrDXXrEEfg6HI3lamkFhEnCviIwH3gHWABERGQr8APD7mF4XkZ+o6rvBnVX1QeBBgJEjRyptkP79+1ffEC6BDl2qe835vH8DLPpHbF2y4LjHYXAdls9s5yJWVpbYsUEV7rsP3nnHlMm77rLtubnw8cfV65aUOKHkcDSETAqlNUCwh36Qt60KVf0e05QQkXzgNFXdJiK/Bj5S1WKv7GXgYKCaUGoPzJ49G4CTTjrJi/JdXrvb9ndvQd/9YK/xtt59KPTdN1YeDUNlWUy56tApsXBrR8RH+A6iahoRwO9/DwMH1n4cVZf7yOFoCJkUSvOBYSKyCyaMzgTODlYQkd7AFlWNAtcAfkydb4Ffi8gU7BU6Grg7Uw1vSfzhD38APKHku24neoOWboTtK+DAa2H30xMfLFxuzgw53oCadh7jbsMGM8VpnI79xhvw6qtw/fXw9dd2uZPxyHOODQ5H6mTM+05Vw8BE4FXgK+ApVV0sIpNFxI9tMwZYIiJLgX7Abd72mcDXwBdYv9Nnqjo7U21vScycOZOZM2faSiRUe8V182zef1TtdVShY7552GV3jCX3a4eUlcHWraYlxQdBfeUVeOkl256Ki7iLc+dwpE5Gv+VUdQ4wJ27bDYHlmZgAit8vAlzU5A1sBfTu3Tu2Ei6rXbtZ+x+L3NBnROLycLl55rlgq4B5zeXkJO4H+uADc2pIVcg4oeRwpI57I7Uynn1mJiiMG3eqedKtnw+RCigohB7DYhXXzbP+pPhxRpFKq69RG4/UTikvj4URikbNMSFRbLo1a2DVKrjgguSPrVozDYXD4UgOJ5RaE9Ewf/6TuXyNO2IErHkPXrswVt5reMyle/Ni2O+y6vtr1MY0dR1kLuTtJM15JGKpJ/wEepWV5r4d1GSC3nbBgKovvWTLhxyS/PnCYed553A0FCeUWhOVpTz/+P3mbdcxH7Z/bdtPegY2L7J8SKEdtq3/KBh6smlTPqqmHbXxIKsVFRDyutv8OHaRSExzETGtqLYxwlOnWlDVK66A3XYz4bTnnsmfPxJxyfkcjobihFJromIb3Xr0ipnkNn8J+QNhp4Ns2udX1eurWiy7rt5AYpE2HzZI1UxulZUxodOpU2oBVf/7X9OsAEaPhrlzE5viSktjKdKDWWijUacpORwNxQml1kI0DOEynpz9bwDOOO1kE0q94sMHBvephOzcdmOmA9OSKisbnruostLcvo880tZrc+tWtWnnnc1ct359LPBqJOLGKDkcDcUJpZZMuNw87MAbkyT89e+WuuKMk4+BbV9D4bG17x8NJ05b0YbZvr1x44O++cYE0x571F2vogLy82PZZDt3NmHk48YoORwNwz06LZmyzVBZHHP7zunMnGe8fEpbl1kSvro0JY1ATvvIwV1cbGONtm0zYdFQliyxeX1CKRyGbt1i687bzuFID04otWQiXgghib3tOnf2Oke+9YKr1yWUALLavh2posL6kTp0MM2lMUHO+/WDcePMwSGIqp3Hj/YgEtOSHA5H+nBCqaUSjUAkbAn3Ajw+4xkAzh282MoKChPvr17E8DYolFRj3nUA69ZZH046hMSoUTbFU15uQs9PcZ6b6zQjh6MpcEKppRIN19z26oX8/c7XATj3EoHe+5iJLuT1O2UHAqpGw7beBnMjlZbCt9/GxhllZcWERWPZvBl69qx52SIR06IaYxp0OBz144RSS0XD1d+MG7+Ala/w+uQjLA9ShywYcrTFv+vcx/qdyjfHxiWpQl7vhIdu7RQVmZt3Os1nq1bBv/8NN95o45OuuKJ6uYv67XBkBieUWiqRULW+JL6cDh3yyDn6XugU6GEPFVu/U3ZH6NjVojb4SNuzL0WjsGNHegenbttm/Ujr1tn6vvsmrueEksPR9Dih1FIJ7YBNi0xbioZh+XMw9BQeefoVAMY22InjAAAgAElEQVSfe0asrh9UVaTNp5/wnQ0aa5VcsgQGDTLhdu21sGkTPPMMDB8OBQXV64bDppm5PiSHo+lxQqmlsng6fHB99W3Df8kjd9wMeEIpGjGB1AY1oiB+4j0wLamxY4AeecQE0csvwz77wH77WfpyP715PI0ZjOtwOFLDCaWWhCrghQrYvAg6doOxf7Wy3O7QZx/mvhzI7KE1vfPaGqrW3+MPTFVtmOmurMy0odWrYfJk2H9/KCw0jetXv6p730gkfY4UDoejbpxQaimEK6DoW8AbCLP9G+gxFAaPrn2faAQ6te3BMhUVpik1VlP58EM47zxb7tsXpk2raaYLUlISG5PknBwcjszhhFJLQSOAlwkWoGgVDKopkB56+J8A/Pr8c2yfNh5gtaQktWR5qhaHztesPvsMjjvOonz/8Y+27ZBDoHc9jol+XDtIPv25w+FoPE4otRQ0EDgttANK10P3XWtUe/LZFwBPKCGWF6kNs317agLhX/+C3/2u+rZHHoGjjoIzzki4Sw38gKouYoPDkXna9hutNRENxxwWtq+webfdalR7Y9ZjgFr2WIgNlm1jRCIWtSEcTk04vPQSDBkCl3n5Dfv0gSOOSO3cqZ7T4XCkDyeUWgrRQAKgbZ5Q6h4nlMLlXk4k742Z07VNet75zg3hcGqmO4CHHrI4eLvv3vDzRyJOKDkczUVG32gicqyILBGR5SJydYLyISLypoh8LiJzRWRQoGxnEXlNRL4SkS9FpDCTbW9yIpWxMUbbvjZh060wrk6I+6e/wP3Tn4P8AdC5bUZsiETMDTs/P7XkfGCeeY0RSGDu586xweFoHjImlEQkG7gPOA4YDpwlIvEhrqcC01V1BDAZmBIomw7cpao/AEYBG5q+1RkkWhkw330NXQcDWVBZZlNoB3Tqxuw5rzB79uxmbWpTE4mkNjhWFZYtM1fvRx5JTxtcPiSHo3nI5KM3CliuqisARGQGcDLwZaDOcOB/veW3gFle3eFAB1V9HUBVizPV6IxRtgUiZYDA1qXQbVfrN8rtQdW3Q6cCXn755eZsZUYIJsurj2gUJk6E55+39XPPTU8bnFByOJqHTD56A4HvAuurgQPj6nwGjAPuAU4FuopIL2B3YJuIPAvsArwBXK2q1V5fIjIBmACws+/P2xoIl8PTh0OoKLbNdwfP7QlZbTt0UDyVlXWXf/RRLPrCbbeZQPqf/4Ef/Qh+/OPGndsPYeSEksPRPLS0R28ScK+IjAfeAdYAEaydPwH2A74FngTGA/8I7qyqDwIPAowcOVIz1ehGU7LWBNKeZ8OAA82MN2iMzeME0j333APAb3/722ZoaGYIhWp3cFi61DSj116zFBNffQW/+AVcd116snSEw9CxbQ/9cjhaNJkUSmuAwYH1Qd62KlT1e0xTQkTygdNUdZuIrAYWBkx/s4CDiBNKrZYd39t8yFFQeLQtRxKrC2+++SbQtoVSRUXtQmn2bFi71oQHwP33Q/fujT+nqoUiCoXqH1jrcDiajkwKpfnAMBHZBRNGZwJnByuISG9gi6pGgWuAaYF9u4tIH1XdCBwBLMhYy5uakrU279w3tk0jlpIijhdeeCFDjWo+QqHatZUXXzTTXV/vUjVUIEUiJvx8wmETRrm5TlNyOJqTjHnfqWoYmAi8CnwFPKWqi0Vksoj81Ks2BlgiIkuBfsBt3r4RzLT3poh8AQjwUKba3uRUCaU+sW0aiY1HakeomoBIlCZi6VKbTjyx8ecpKYFu3aBHD5uGDDGhlJ/vhJLD0ZxktE9JVecAc+K23RBYngnMjN/PK3sdGNGkDWwufKGUFxRKCtk1/56pU6cCMGnSpEy0LOOEw7FAqAAzZliOoxEjYI535xx/fOPOEQqZRtSnT/11HQ5HZmlpjg7tk5K10KlH9eCqqgnj2n344YcZbFjmCY5RikZh6lRzZBgxAkaNgssvh379GnZcX9iVl8PgwXXXdzgczYMTSs2JRi1lRcm66qY7sDdzVs2/55lnnslQ45qGaNTSjwe1oY4dY4IoFIptnz/fnBp87/5DDrEpVUIhczP3zXLdurn8SA5HS8UJpeYkXA7bV3lCKejkoAndwdsCFRWWWsIXEKqxrLI+flTwWbPMzHbUUY07Z3m5CTYniByOlo8TSs1JNGyCp3yLxbkL7QDEyyqX+A16xx13AHD11TVCB7YKSkstrlx9Me22b4fp0+GnP00902wkEosKEQ7b/k4gORytAyeUmpNIBZAFZRsgtxd06mZ9S1CrlrRw4cLMta8JKCpKzrtt40abn3566ucoKTEvOhE7V69eqR/D4XA0D04oNSeREERKzYyX1weyO0GHujPazZgxI0ONSz/hsPXv1JfafMsWc0T46KPUHRJUbeDtwIHpifDgcDgyS9tLxtOaiFRYIFaAvF4JHRvaEsHBqrURicB++8Gf/tQwD7lQyEx1TiA5HK2Ttv0WbMmoWp9S+WZbz+sTy6dUB7fccgsA119/fVO2Lq1UVsK331b3gKuN9etNo9ppp4afy5nrHI7WS4OFkoh0J07TUtUtjW5Re8EPcF7qpYXK65VUFtklS5Y0YaOahooK04AKCuqvu8aLhjhoUN316qJT3RZQh8PRgklJKInIEOBvWDig4DevAAq0PR/mpiIaBhTKvB79JDWlxx9/vGnb1QSUliaf1nz1apunKpR8jzvfucHhcLROUtWUHga6AxcC32OCyNEQKovhmWOheDVkdYRO3ZPSlFojJSXJC4qGCKWyMhvrlJtrA2Ndf5LD0XpJVSiNAg5S1UVN0Zh2xZalULQSCo+BXY63CKRJCKUbbrBQgZMnT27iBqaHSMScD5I1qR10EFx1Vd3jisrLre/IFz55edC/v41/cjgcrZtUhdI3gLPYp4OiVTb/4cXQb39zD0/iE/+7776rt05LIhg2KBkOOMCmuqistAgN9Q3AdTgcrY9UhdJvgSkicomqLm+KBrVpKopiyfu2f2PzLgMsBl4S/UkADz/8cBM1Ln0EQweVlydOQ1Eb//2vaT215UmKREwjym1/WT0cjnZBqkLpeUxTWiIiFUA4WKiqSfhXtVNUoXQ9VQ6LJWsBgc792lTupGgUvvsuNiYpGk1eo1G1XEnnngs33ZS4Tnm5uXy7fiOHo22SqlCa2CStaA+olzuho/eGLttoAik7B8JlSQ+cveaaawCYMmVKU7W0UWzfboKjvqgNidi61ZwW4p0cduyICSERCyHkcDjaJikJJVV9tKka0uaJhquvF38P+QNsWaNJC6XNmzenuWGNIxy2eHZ+KopNm1IPoArw29/CN55FMyiUKirseH4OJRHo4IZ8OxxtlpQfbxHpBJwDDMdcwhcDT6hqEkFk2jHxQqnke+ixhy2rQlZyrmMPPvhgmhvWOEpKYN26mMt3bm7dfUizZ8PixbZcUAAXX2yCprzc5qNHV3d0CIVMIDnPOoejfZDq4NnhwCtAAfCFt/nXwM0icqyqfpXm9rUdwhUxZwZV05QGHx4rb6VjlEpLTRAl43iwcSNMnGj9TL7gGjoUjj4aHnigZv1IxLQi52XncLQfUtWU7gE+Bc5T1SIAESkAHgfuBo5Jb/PaEJHyWDqK0HbrR8rfKWb3StL7btKkSQBMnTq1KVqZMmVlyWsxTz1l5r633zZhVBfbtplA6tvXOTU4HO2JVIXSocABvkACUNUiEbkW+Ki+nUXkWEywZQN/V9U74sqHANOAPsAW4FxVXR0oLwC+BGapautyuohUQLZn4yr+3ua5vSFUbM4OSWaZLSsra6IGpk4kYkImWffsU06Bnj3rF0iRiB1z110b30aHw9G6SFUolWNhhuLp5pXViohkA/cBRwGrgfki8oKqfhmoNhWYrqqPisgRwBTgvED5LcA7Kba5+dEoRCuhg/f29oVSl37QpS/k9kj6UPfdd18TNLBhJDswdupUKC42N++zzqq/vj8WyeFwtD9S7ciYDTwkIoeKSLY3/Rh4AHihnn1HActVdYWqhoAZwMlxdYYD//aW3wqWi8j+QD/gtRTb3PwkcnIA6Nw/aQeHlkgyQmnDBsuN5Ds3JEM06oKqOhztlVSF0m+BZcC7mGZUDrwNLAUur2ffgUAwRs5qb1uQz4Bx3vKpQFcR6SUiWcAfgEl1nUBEJojIAhFZsNHPp91cRMNQWeJNpVCyHpY/b9Oa96wPKa93yg4Ol19+OZdfXt+lbjpUY1Npaf3u2fPm2dwbXpUUTig5HO2XVMcpbQNOFpFhwJ7e5q/SGHJoEnCviIzHzHRrgAhwCTBHVVdLHb3eqvog8CDAyJEjmzeCeagYitfENKF5t8PKV2Pl3YfZ2KQkHRxaAqGQRfEOe4pfJFL/INn//Me85/bZJ/nzRKPOfOdwtFcaNAxRVZdhGlMqrAGCCa4HeduCx/0eT1MSkXzgNFXdJiIHAz8RkUuAfKCjiBSr6tUNaX9G8PuQOnj+zNu/gYE/gUMtcyydvdGgSTo4+Nx9991pbGRyhEImgNautfVUIip89BGMHJm6kEk2/5LD4Whb1CuUROTPwDWqWuIt14qqXlZH8XxgmIjsggmjM4Gz487VG9iiqlHgGswTD1U9J1BnPDCyRQsk8KJ+++OSolD0LQweAz2GxeqEilv8+KRwGFatMnNddnbqY4Z+8Qvo3Tv18zqh5HC0T5LRlPYBcgLLtVGnuUxVwyIyEXgVcwmfpqqLRWQysEBVX8Ay2k4REcXMd79Jon0tk2gIxLu8pettnFLBkFi5qgmkFIXSb35jlyRTXnilpdbUZLWjLVvg/fdtn86d4bzz6t8nEU4oORztk3qFkqoenmi5IajqHGBO3LYbAsszgZn1HOMR4JHGtCMjRMPQweut3+7lTioojJVrNGXTHUBeGsMb+M4K/vjdRJrQtm2pOR1cdx08/7wtDxkCY8em3i6R1NJdOByOtkOjQ1uKyFBgtarWOU6pXRH1IoL7ThlFiYRSxNKgp0g6IzmUlcG338a0kmgUBg+OBVQNh61OshG/v/8eXnzRUk9ceGHDAqf6oYVcFAeHo32Sauy724El3uBWwcYMHQlsF5HjVLXeqA7tAo1QzZpZtNL6l/IHVq+TXUfO7wxQXGxakK8dRSKwZk1MCEUiqR3vhRdMFk+caMKtIUQizh3c4WjPpGokOQdY4i0fB+wLHARMx6IvOMA0pSBFq6DrIAsn5JNCZPAgEyZMYMKECY1soJ2+qAg6BZLb++a7sjKbQqG6+5JKSuDMMy2g6qJFcNFF8OqrDRdI4ISSw9HeSdXA0g8b9ApwPPCUqs4TkS3AgrS2rFUTBQL2p6JV1Z0cIKUcSkF69erVuKZ5VFSYAIjvu8nOTt7J4P334d134ZBDTLiJwPDhqbclFIpFhwiFGuat53A42gapvhU3A0MwwXQ04Ltld6DaW7idEwlX7xQpWgm7nVSzXgMGzjY242w0alpQaWnjnQnee88Cpz7+eHWNKxVUTUAOGBC7ZMkGeHU4HG2PVIXSM8C/RGQp0BNz7wYz46UrqkPrJxqCHd+aGS9cBhXbqjs5+DRDNIegc0PnRnZpffABjBrVcIEEZgLs3dsS/jkcDkeqQul/gVXAzsDvVLXE2z4A+Gs6G9aqWfsfmBWnGXUfajHwNGrrGm3QwNnzzz8fgIcffrhBTSstre7c0FAqK6F/fxgzJrX9QiHTjHytKCcHeiQfJN3hcLRxUo19F8YCo8Zv/1PaWtQW2OpFYPrJFMjra+GGBv7EBtDm7xR7IzegT2lwY7wIgB070uNIkJNjZrtUiEZNIA0ZEmuDiHP/djgcMZIJM/QjYKGqRr3lWlHVT9LWstZIpNIET4kXJG7YaZDjDfqJRkwIdUwhcFwCJk+e3OB9KyttSrXPpqgI/vtfS1n+lZfwvm9fmDUruf3DYdPQRKBfP9dn5HA4aieZT/UFQH9gg7esJHZqUCx8UPuloghK11lYoY5dYwIJQMMNGiybToJms1T4xz8sUV/37mauy8pKzeRWUQF9+kC3bg0bUOtwONoPybwidgE2BpYdtaFhiwpevjkWBdwnGoWcRngEeJx77rkAPJ6k7ayoyLQjSC7/USKOOgoKC22eSoRwn2jUokQ4geRwOOojmdh3qxItOxIQDZvzQsn6mkJJI9Ch8UJpjz32SLpucbGF/gmmjUjFdPbOOzYY9sorYe+9U2hkAD/akhsQ63A4kiHVMEMTgW2q+njc9nOBAlW9P52Na3X4Qql0PfQfVbM8DS7g119/fbX1UMjcvKGm08C6deb2XZuG8uKLsGxZbN+TToLddouVv/SS9RvddFPD21tZaW1wAVYdDkcypGpQuRy4MMH2lcDDQPsWShoG6WiaUpf+cWXaJOOSduyA9etNG9K45CE5ObULpKIiCwsU5LHH4LXXwA8a8c47Fq2hIVlg/baEQs7l2+FwJE+qQmkQNk4pntVeWftF1TzsKrfb4Nl4851Ig1zA4znzzDMBmDFjBgDl5TbmKNUBrAUFMH++NatvX/Oqu/VW02y2boW//c0G2cYLrmQoKooJw4YkBnQ4HO2XVN+S67DoDSvjtv8I2JSOBrVaNOolKFpn610CQsnvWElDltl999232npFRcP7a3baKba8997gyTlWroR77zWnhlTzIfku54WFDWuTw+Fo36QqlP4F/FlESoC53rbDgbuBf6axXa0PP1JDyXqbd+5fvSwrPUmCrr46lgU+GrUxQKmO+1E154UTT0wckWHIENOSGpJsr6LCxiI5HA5HQ0hVKN2IuYW/Cvj5GbKAp4Hra9upXaBRe4tXaUpBoRSG7MZ73sXju3qnytdfwxNPwA9/mLhcpOHpyP006A6Hw9EQUg0zVAmcJSI3YGY8sGgPy9LestaGRm1IcYknlHJ7QKUXGjBaCTnpiTh62mmnAfDMM88QDtd0bqiLcBjGjYt53I0e3fj2RCIx779o1LS2hjhGOBwOBzQwHbqqLhORImCjqm+3au9ELaZF6XrI7WnSIrdHzLkhGN2hERx88MFVy6FQaua15cvh44/NZPfjH8POOze+PaWlFq3BF0SNiRjucDgcqY5TygFuAy4G8oDdgRUiciewqr5xSiJyLHAPFo7o76p6R1z5EGAa0AfYApyrqqtFZF8sCnkBZja8TVWfTKXtTU40DOs/hi3/Nc87AXLyISe9rmeTJk2qWi4vTy1KQv/+cN99cNBBttxYfP+Nbt0abu5zOByOIKm6g90InAScC1QEts8Dxte1o4hkA/dhadSHY2bA+DylU4HpqjoCmEwsxXop8AtV3Qs4FrhbRLqn2PamZeWrMOdsWDcfuu3iRQhM/4jRaDQ2lZWlJpS6d4dTTkmPQAJzasjPdwLJ4XCkj1TNd2cBF6jq2yISNNstwrSmuhgFLFfVFQAiMgM4GfgyUGc4lrMJ4C1gFoCqLvUrqOr3IrIB06a2pdj+pqPIG751zMMw4EBbzkrv2zochmOO+Smq8Le/vUAkkprn3Usvwe67w7BhqZ23rCymFWVnx5wI/ZxKDofDkS5S/ZTficSDZztQv4AbCHwXWF/tbQvyGTDOWz4V6CoivYIVRGQU0BH4Ov4EIjJBRBaIyIKNGzfGFzctpRtsPngMdOoGaNo1pR074OCDj2TMmCPJzzezWbJUVsJll5nXXSqEvczuvXrZgNsOHawfKyvLzu/SUDgcjnSSqqa0GDiMmoNnfw58nIb2TALuFZHxwDvAGmKu54jIAOAx4JeJHCxU9UHgQYCRI0em4JeWBko3QccCyO4YCymURqGkapEWLrrotw0yly1dan1QtbmB10ZlpQkjFyrI4XBkglSF0s3A4yIyGHNW+JmI7AmcDZxQz75rgGDa1EHetipU9Xs8TUlE8oHTVHWbt14AvARcq6ofpdjupqd8k3ndgTdYNjXJUVlpAVSjnqjNyTFNxPdqC4Vsaohm8umn8NRTtjxiRGr7hsNu3JHD4cgcqY5Tmi0iPwd+D0Qxx4dPgJNU9Y16dp8PDBORXTBhdCYmzKoQkd7AFk8LugbzxENEOgLPYU4QM1Npc8Yo2wx5nqVRIykn9AuFoKQkJgDKyy31hI+qCaRzzz0OgMcff7nO4/l9QADPPAPTp1v/T0PC/7i0Ew6HI1MkLZREpANwNPAfVU152KWqhr3UF69iWtY0VV0sIpOBBar6AjAGmCIiipnvfuPt/nPMbNjLM+0BjFfVham2I21o1EIK+VbE8i1QMCRWlmLw1fLy6lG9a/OqGzv2pKSO99xz8MILcPfdcMUV8KtfWb9QMNJRZaWNM/LNgZEIdO0aG/sUjVqZGwzrcDgyRdJvTk+oPAvsCWxuyMlUdQ4wJ27bDYHlmUANTcjL35RcqtVMEQ1DxXbo4NnTKrZC3o9sWaPWt5QCyWaFHT/+kqplVYvOsPvu5p595ZWx0EMffAADBlh/UFZWLB1FkIoKC8rqO0xs3QobNphgAtPeuqRnzK/D4XAkRao98Z8BQ5uiIa0OjZojQ3ZHyMoxTSm3V6wsBU1JNfWBsGCC58YbYft2i6Tw7beweLFNAwbAHXfUH/EhGIGhe3czHxYX21RR4YSSw+HILKk6OtwE/EFEbsS87UqChaq6JU3tavkEnf9C201zyguoIykk9AuHzVSWTBDxM86wXBJPPvkGixdbIr5w2MpmzUr6lFUx84L9RSIwcGDseOBMdw6HI7OkKpRe8ubPYjELfMRbbz9j+4NCqcyzZvqaUopjlFKJ9v3Tn55RtbxsmZnlEpnmkjlnojTlWVnOscHhcDQfqQqlw5ukFa2RaGVMtSn3FMQqTUlS0pQqKpIPrHrOOb+uWl6yxPqTGoJLU+5wOFoiSQklEekM3AWcAuQAbwCXqWr7zTYbDce0oXhNSZPTlPzU4yUlqfcn+U4Op5yS2n6VlRY2KDvbRWNwOBwtj2RtTDdjAVdfAp4AjsKidrdfgkKp3BNKHbtCqDjp1OelpbBliwmYZFM+nH76GE4/fQxlZTBypE2pUFkJffvCrru6NBMOh6Plkez3+TjgQlWdASAi/wTeF5FsVY3UvWsbJRqmSqb7mlJOV+jcx7LMJuG1UFRk2koqfTg/+9l4wPqDHnsstSaDOVR06uQiezscjpZJskJpMPCuv6Kq80QkjAVo/a7WvdoyGgbxLl/ZJkvi16ETdMiLjV2qAz9ja35+aqc944zxdnpNzlsvHtXUTYUOh8ORKZI132UDobhtYRqYubZNEI0EzHdbIK+3LSfpdVdRUX+dGqeMQlFRJUVFlVx1FZxQX7TBBIg4N2+Hw9FySVaoCBaINfgqzQUeEpFSf4Oq/jSdjWuxaNTi21V53232grHW7eAQicQCrpaUpGZCC4XgZz+DBQuO8rbM5aCDUmt2NBpLPeFwOBwtkWSF0qMJtrWssD+ZRKPwyZ9h0+e2vvEz6H8gdbmCq8KqVbGBqdFoaqa7rCw46ijIyfkVffrA3nvD6BQjEFZWOucGh8PRsklKKKnq+U3dkFaFRmHxI9CpALoOhp57wtBTTUuqpaOnstImP65cbbz9Nnz2mXnlbfb9J3Lgj3+EiRNh4sRzG9zsSATy8hq8u8PhcDQ57bdPqDGEiiFcCj+6DPa71LZFI+b8UAsVFbU7JpSVWXn37vD66/DwwyY8evc2DSnYB1RWZtbSvLzUkxz5nncOh8PRUnFCqSGUrre579wAXoDW2i9ncXHtXm9vvgkXXQSvvWYBVq+/3tzEEwmx8847HoCZM+cm19TSWD+W36fkcDgcLRX3imoIvlDKDQadi9aa2E/VHBtqM53Nm2fjlXbfvX7PuPPOuzjpZlZWmhDq2ze2zcW1czgcLRknlBpCSQJNKRqtJlFUYxpKKFR3FPD58+FHP0rOVfvkk8+ov5JHeblF/XbpzB0OR2vBCaVkqSyDSLktF39v87x4TSkmVYqKYO3amCCqzWxWXAyLFsGllybXjKKi7QAUFHSrURaJxCKOq5qQc/mQHA5Ha8IJpWQp22TODZINJWttW7U+JYWsmDt4ebmZyuoLevrJJ6ZFjRqVXDMuuOBkINanFArZ5EdqCLqZd+3asKgPDofD0Vw4oZQsGoYOnU3whIoslFCHOLtYYOBsWVndTgWRiHnW7b47TJkC+++fXDMuuOCyauuhEPTpYwIwL88NjHU4HK0bJ5SSJRqBDp6XQPlmyO1dUw3xhJKqCYu6BsfOmGGu3089Bb/4RfLNOP74cTW2deniHBgcDkfbIKPf1SJyrIgsEZHlInJ1gvIhIvKmiHwuInNFZFCg7JcissybfpnJdqPquXx7Qqhsc1x/kt9Iu5zh2ocrVTFjhpntUk20t2XLJrZsiaWxcgFWHQ5HWyJjQklEsoH7gOOA4cBZIjI8rtpUYLqqjgAmA1O8fXsCNwIHAqOAG0Ukc3lTNUK17O9lmxIIJU1aKC1dan1JZ5yRep/PhAmnM2HC6YCZAHNynMnO4XC0HTL5jT0KWK6qKwBEZAZwMvBloM5w4H+95beAWd7yMcDrqrrF2/d14Fgs4WDTo1EsJq1H2Sbo+YO4SrG4d6H4eOoB/vAHuP9+025OOy31pkyY8P+qlsNhFzbI4XC0LTIplAZSPffSakzzCfIZllDwHuBUoKuI9Kpl34HxJxCRCcAEgJ133jltDTeh5C9rLFVFpNLfWC3uXXl5zQjg778PI0bAPvvAOefYvHdvUuboo0+qWg6HXUpzh8PRtmhphp9JwGgR+RQYDawBks5sq6oPqupIVR3Zp0+f9LUqmFy3shgiFZDbHaIhTxhlQ6fuVVXKy6sPhN2wAX7+c/jnP+Hoo2HyZEtD0RA2bFjHhg3rrFkppFF3OByO1kAmNaU1WAZbn0HetipU9XtMU0JE8oHTVHWbiKwBxsTtO7cpG1uNoPmuzHMyyO0JOfmQP6CqWkmJRfcuLYWCgtju8+bZ/IADGt+USy45E7BxSs7JweFwtDUy+UqbDwwTkV0wYXQmcHawgoj0BmD2N0oAACAASURBVLaoahS4BpjmFb0K3B5wbjjaK88M0XDA884XSj0gq/rlKy42LalLl+oODH5su332aWQzonDhhea0WFJi53BCyeFwtCUy9kpT1bCITMQETDYwTVUXi8hkYIGqvoBpQ1NERIF3gN94+24RkVswwQYw2Xd6yAhBoVTunbZTrxpCqbzczGnxgsKPbZfqWKKyMvOwAzPVicCppx5b1V/lssg6HI62Rka/s1V1DjAnbtsNgeWZwMxa9p1GTHPKLOsWwIKptuyHGOrUvZpQ8gfMdu5s83/9yzLFdutmse0uuyzBcQNEIiaEgsfr3r167LpOnWDdOvP3GDx4MA6Hw9HWcMafZFj+PKyeC71HQHYn2OV46Ny3WurzSCQWCfytt+Daay1lxLHHwiuvmHCqi/Jy6NkzFtE7KyuxZ915550HwNy5c9Pz2xwOh6MF4YRSMpRtgM79YdxLsW2h4mqx7sIBC98XX9j8sMNMuOy1V/2niEYtgGp93nTXXXddio13OByO1oMTSslQtgk6J3AxjxNKPosXw7Bhdce+C+JHZkjGvXvs2LHJHdThcDhaIa6bvD406g2WrT2sEFgeI9/pYPHi5LQjn4qK6i7kdbFixQpWrFiR/MEdDoejFeE0pfqIRkxT6hUvZaRan5IfxWHHDti4Efbeu/5DV1aaQIpGk0/Gd8EFFwCuT6m5iUajbNq0iW3bthGJJD2+2+FoVrKzs+nevTu9e/cmq4W67jqhVBelmyx3UvmW6uY7rR5WCEwodehgJrilS2MZYOuirMzSlefkJB8u6Oabb07xRziagtWrVyMiFBYWkpOTg7hsio4WjqpSWVnJ+vXrWb16dXpDsaURJ5TqonKHOTREK6ub7zRKlGx2bDctB8wN3O8TysmpHmbIx/fQ8+v36GHODakwevTo1H+HI+2UlJSwxx57tNivTYcjHhGhY8eODBw4kCVLljR3c2rFCaW6iEagYpst5wZTn0cpKu7A2uKY8IlG4bnn4MMPYcAAuOKKmocrLo45P3TpAr0SpGSqD/9m2mOPPVLf2ZFWnEBytEZa+n3rhFJtaNRzcths6wHzXWUowqatHenaM+bc8MILMHGiLZ9ySs3DVVaaIGrsmNeLLroIcH1KDoejbeKEUm346Sq8WHdby3uxxXd6CyvZeR2rhfhZutQE1LvvwqBB1KCy0gbHNpbbb7+98QdxOByOFkrL1uOakyqhtBGA4mgf8vKgS2fI7xwlN6+6PF++HHbeGQoLEwdJjUTSk/vokEMO4ZBDDmn8gRyOJmLTpk2ISEra/E033cTeybisZoh169Zx9NFH06VLlyonlsLCQqZOnVrnfvn5+TzyyCMZaGHbxQml2oh6KdDLzHwXyupJVpWDlVZzBwe46CK46aa6D5lqQNZELFq0iEWLFjX+QI52yfjx4xERLrzwwhplV111FSLCiSee2AwtS465c+dy4okn0rt3b/Ly8thzzz259NJLWblyZVrPM3XqVL7//nsWLlzI2rUW73L+/PlccsklaT2PoyZOKNWKl0OpbBPaqQegECmzKRquNnAWYL/9LABrwiNFzSEiHWkmJk6cyES/88rhaACDBw/mqaeeoqSkpGpbOBxm+vTpLdZNGOCBBx7gyCOPpFevXjz99NN89dVX/OMf/yAajXLrrbem9VzLly9n//33Z9iwYfTv3x+APn360NkPTuloMpxQqo1An5Lm9kEi5WiHfDSngGhuXzQrpvZs3WpBV7duje0ejdrA2IoKS/qXrnv5rrvu4q677krPwRztkhEjRjBs2DCeeuqpqm0vvfQSubm5jBkzplrdaDTKLbfcwuDBg+nUqRP77LMPzz//fLU68+fPZ//99yc3N5f99tuP//znPzXO+eWXX3LCCSfQtWtX+vbty1lnncW6deuSbvPq1au57LLL+M1vfsOjjz7K4YcfTmFhIYceeij33XdfNbPas88+yz777EOnTp0YPHgwt912G6paVV5YWMitt97KRRddREFBAYMGDar2TBUWFvL8888zffp0RITx48dXbQ+eZ/ny5YwZM4bc3Fz22GMPXnzxxRrtXrNmDWeeeSY9evSgR48enHDCCSxbtqyq3Ddbzpgxg912242uXbtyyimnsGnTpmrHefTRR6t+U79+/fjlL39ZVbZ9+3YmTJhA37596dq1K6NHj2bBggVJX9uWhhNKteFrQ2WbiHTqRXYWaKdeaG4fNLd3tbQVCxfChRdC0PW/tNTMdbm5NhapvijhyXLAAQdwQDpS2DqahDFjak73329lpaWJy/0uiE2bEpc/+aSVf/ddzbKGcuGFFzJtWiwTzLRp0zj//PNrDAK+5557uOuuu7jzzjv54osvOPXUUxk3bhwLFy4EoLi4mBNOOIFdd92VBQsWcMcddzBp0qRqx1i7di2HHXYYe++9N/PmzeONN96guLiYk08+mag/cK8enn76aUKhEFdffXXC8u7duwPw8ccf87Of/Yxx48bxxRdfcMcddzBlyhTuvffeavX/9Kc/sc8++/DJJ59w1VVX8bvf/Y4PP/wQMCE7duxYfv7zn7N27VruueeeGueLRqOceuqpRKNRPvzwQ6ZNm8ZNN91ERUVFVZ3S0lIOP/xwcnNzefvtt/nwww8ZMGAAY8eOpbS0tKreypUrefLJJ3nuued47bXX+PTTT7n22muryh944AEuuugizj//fD7//HPmzJlT1f+mqpxwwgmsWbOGF198kU8//ZTDDjuMI444osrs2Npw3ne1EQnFhFL+XmRlS41+JJ+vv7b50KHVt/fpk55+pCD+y2DfffdN74Ed7Yqzzz6bSZMmsWzZMrp27corr7zCX/7yF2644YZq9aZOncqkSZM4+2xLEj158mTeeecdpk6dyuOPP86//vUvQqEQDz/8MPn5+ey9995ce+21VSlWAP7617/ywx/+kDvvvLNq2/Tp0+nZsycLFixg1KhR9bZ32bJlFBQUsNNOO9VZ749//COjR4+uinyy++67s2zZMu68804uvfTSqnpHH310lRn80ksv5c9//jNvvvkmBx98MH369KFTp07k5eVVme7ieeP/t3fv0VFV9wLHv7+8SMJbQ4I85CEQoFyUx9WqoBTwNvUVKRUQFbxYWbX4BEGkLrRqrb2LCL4VUeCiFxDxARRpgVoCFBTRFAyJBBMpBpRoQcAEEsjv/nFOhpnJJCSQyQyT32etWcnsc+acfeZM8pu9zz77t2YNO3bsoKCgwNPlOWvWLAYOHOhZZ9GiRagqc+fO9QT7V155heTkZFasWMGIESMAp+t03rx5NHe/uY4fP565c+d6tvP4449z3333MXHiRE9Zv379APjwww/JysqiqKiIhIQEz/rLly9nwYIFTJky5VRvbdixoFSV40fhQB6UFFHaPInoGN9phbzt2uUk5Ku4GVbVGR4eaFaHM3XfffcBdp9SuKrutCQmVr88Kan65e3bV7+8Nlq2bMmwYcN4/fXXadGiBYMGDap0PenQoUPs3buXyy+/3Kd8wIABrFzp5OrMycmhd+/eNPGaEv/SSy/1WX/r1q1kZmb6rFPhyy+/rFFQ8u5+q05OTg7XXHNNpfr+/ve/59ChQzRzZz7u3bu3zzpt2rRh//79NdpHxX7atm3r855dcsklPjembt26lYKCApr6TdtSXFzMlxXfZIEOHTp4ApJ/Xfbv309hYSFDhgwJWI+tW7dSXFxMq1a+WQyOHj3qs4+ziQWlqmydCZ85zfbSuNZEx0QTaNrNkhJYsAD69TsZs0pLISGhyhh2RmbNmlX3GzUN0rhx4xg7dixNmjThscceq9VrazPXX3l5Oddcc03A4dQpKSk12ka3bt08QfJUraWqeNc51u8bo4jUuCuxpsrLy7noootYtGhRpWXneN20eCZ1KS8vJyUlhfXr11da1qymqQfCjF1TqsoP+ZTHJ3Pg4tf4oc3NPgMb9u1zMsvu3XtydvCf/ezkS8vKap5LqbYuuugi67ozdWLIkCHExcXx3XffcUOAaUgquss2btzoU75hwwZ69uwJQI8ePdi+fbvPSL7Nmzf7rN+3b1+ys7Pp0KEDXbp08Xn4tyKq8qtf/Yq4uDieeuqpgMsPHjzoqU+g+rZr167G+6qJHj16UFhYyJ49ezxlH3/8sU8w6du3L7t27SIpKanScZ9Twzvpk5OTadu2LWvXrg24vG/fvnz77bdERUVV2kdycvKZHWSIWFAKRBUt/o7SRu04fG4a8Y0TUDnZqHzjDZg/3wk+LVvCv/5Vea67miTsOx1btmxhy5Ytwdm4aVBEhG3btlFQUECjKj6wkydPZsaMGSxcuJCdO3cyffp01q9f7xnMMHr0aGJiYhg3bhzZ2dmsXr2aP/zhDz7bmDBhAj/88AMjR47ko48+Ij8/nzVr1jB+/HgOHz5co7q2b9+emTNn8vzzzzN27Fj+/ve/s3v3bjZt2sTdd9/N5MmTAZg0aRLr1q3j0UcfZefOnbz55ptkZGTU+bWVoUOH0r17d8aMGUNWVhabNm3i/vvvJ8brvo+bb76ZlJQU0tPTWbduHQUFBWRmZjJp0iSfEXin8rvf/Y5Zs2Yxc+ZMdu7cSVZWFhkZGZ56XH755aSnp/PBBx9QUFDApk2beOSRRwK2ns4G9RqURCRNRL4QkV0iUmkYjYicLyIfishnIrJNRK52y2NFZL6IbBeRHBF5KKgV1XLKS77nRFwr4uIgOkrBDUqlpfDmmzB4MHTo4PuysjKo+MJY1wMcKkyePNnzB2jMmWratGm13Tz33HMPkydPZsqUKfTq1Yt3332XpUuXcuGFFwLODAYrVqwgLy+Pvn378sADD/gMaAA8ra2oqCjS0tL4yU9+woQJE2jUqFGVwTCQ3/72t6xevZqioiKGDx9OamqqZ7j2ww8/DDgthyVLlrB06VJ69erF1KlTmTp1ap3f2xcVFcW7775LeXk5l1xyCWPGjOHhhx/2OZ7ExEQyMzPp3LkzN954I927d2fs2LEcOHCAli1b1nhfd955Jy+88AKvvvoqvXr1Ii0tjezsbMD5YrFy5UoGDx7MHXfcQWpqKiNGjOCLL7447W7OUJOaXkA84x2JRAM7gauAr4EtwE2qusNrndnAZ6r6koj0BFaqakcRGQ1cr6qjRCQR2AEMUtWvqtpf//799bTH6p8o5cSLbShJSeNI3/9Byo5QnpDC4//TnLffdpL4vfGGb5cdOLOAn3uu00oKVvddxWwO4TQlS0OUk5NDjx49Ql0NY05LdZ9fEdmqqv3ruUoe9TnQ4WJgl6rmA4jIIiAdJ8BUUKDia1tzYK9XeWMRiQESgFLgULAqWlpSRmzpAUho5dk5UTF07QpDhkBKClSV1qhZs+CMuqtgwcgYE8nqMyi1BfZ4Pf8auMRvnUeBv4rI3UBjYKhb/jZOANsHJAL3q+q//XcgIuOB8cAZTZdy4sci4iinvJETlIbf1o7zO8aRMRNGjqz+tXUxlVB1/vGPfwDYpKzGmIgUbgMdbgLmqWo74GpggYhE4bSyTgBtgE7AJBHp7P9iVZ2tqv1Vtb//uP3akBLnHoET8Umowuc5jYhrVP0Q2BMnnBZSsLNiT5s2jWnTpgV3J8YYEyL12VIqBLxT3LVzy7zdDqQBqOomEYkHkoDRwCpVLQP2i8hGoD+QTxBUBKXyRq3YXxTFocPRdOsW6C6lk8rKnHuTgu2VV14J/k6MMSZE6rOltAXoKiKdRCQOGAUs81vnX8AQABHpAcQDRW75YLe8MfBTIDdYFT0ZlJLYucuJ2126nrqlVB9BKTU11VKhG2MiVr0FJVU9DtwF/AXIAd5S1WwReUxErndXmwTcISL/BBYCt6kzPPAFoImIZOMEt7mqui1YdfVuKeW5Qalbt+rfKtXgDQP3tm7dOtatWxf8HRljTAjU6zRDqroSWOlXNt3r9x3A5QFedwS4MegVrFC8H5VYNKYpHTuUcdPwQyQnn3rKjmAPcgB45JFHAJv7zhgTmWzuuwCkZD8n4pJAhMEDixl8xVHKpfqgpFo/Qck73YAxxkQaC0oBSMm3/EgSz70QQ/duypCrKvfLHT/u5MeJinICUmKi83uwde5cadChMcZEDAtKAUhJEdsL2vLkLGdCwxdfhPR033WOHYPWrU8m7wv2UPAKa9asAZw5r4wxJtKE231KYeH4of3k7mnDtPuL+KpAKwUkcNKdJyY6wai+AhLAE088wRNPPFF/OzQRQ0SqfVTMIxcMR48eRUQCpgz39+mnn3LttdeSkpJCfHw8HTp04MYbb6Sw0P8OEhOJrKXkT8uJOlbEv4+1YuzoH4mNq3wT7vHjzki7+hht52/BggX1v1MTEbzTY69YsYI77rjDpyyhinsaysrKKuX8CZa9e/cyZMgQ0tPTWbVqFS1btuSrr75i+fLlHDlyJGj7LS0tJS4Uf9CmEmsp+dGSA8REHadTt6Y0a3ayCXT8uNNld+yYcy2pRYvQ1K99+/a0b9/+1Csa46d169aeRwv3A+xd1rx5c3JzcxERlixZwpVXXkl8fDzz58/n5ZdfJikpyWd7q1atQkQ8weL7779n9OjRtGrVivj4eLp06cJLL70EQMeOHQG47rrrEBG6d+8esI6ZmZmUlJTw2muv0adPHzp27MigQYPIyMjwuT9vz549jBo1inPPPZfExET69evHhg0bPMufe+45OnfuTFxcHN26dWP+/PmeZRWtttmzZ3P99dfTuHFjT5LD7du3k5aWRpMmTUhJSeGWW26hqKjoDN95UxvWUvIjsfGUXvkyl/7YGqJOfjssLnYmWxVxbpKtw3xhtbJq1SoA0tLSQlMBU7UP74P9WfW7z+SL4Gd1n4146tSpZGRkcOGFF9KoUSOWLfO/zz3wa/Ly8vjggw9ISkoiPz/fk3xvy5YtnH/++SxYsIChQ4f65B3y1rp1a44dO8b777/PsGHDAma4PXToEAMHDqRjx44sW7aMlJQUsrKyPCnTFy5cyAMPPMAzzzzD4MGDWbFiBePGjaNNmzZcddVVnu1Mnz6dp556ilmzZhEdHc2ePXu44ooruOuuu3jmmWcoKSlh6tSpDB8+nMzMzNN5G81psKDkL7YxJ1LHUJabR5RXUIqKcgY21McIu+pUZN60oGSCaeLEiQGz0VZn9+7d9O/fn/79nawHFa0jgIq5KFu0aEHr1q2r3MagQYOYNGkSI0aMoFmzZlx88cUMGjSIm2++2dNDMH/+fA4ePMh7773nafF16dLFs40ZM2Zw++2385vf/MZzLB9//DF/+tOffILSrbfe6nMdbcqUKVx22WU8/vjjnrJ58+Zx3nnnsW3bNnr37l2r98OcHgtK1XET+5044dyDFOqABLBo0aJQV8FUJQgtllCpCCy1MWHCBEaNGsXmzZu56qqruP766xkwYECttzNjxgwefPBB/va3v7F582ZefvllnnjiCT744AMGDhzIZ599Rr9+/TwByV9ubi4TJ070KRswYABPPvmkT5n/MW7dupX169fTJEAytC+//NKCUj0Jg3+z4UogyglKx4/Xz7x2NVHR/29MMDVu3NjneVRUFP4JQcvKynyep6ens3v3bu6991727dvHz3/+c+68887T2n+rVq0YOXIkM2fOJDc3l/POO69SmvXa8u8K9D/G8vJybrjhBrKysnweeXl5Pi0sE1wWlKqgIiDRgNNSio8PcYVcy5cvZ/ny5aGuhmlgWrVqxcGDBzl69KinLCur8vWz5ORkbrvtNhYsWMCLL77InDlzKC8vJyYmBhHhxInqZ9sPJD4+nk6dOnkGVPTp04dPP/3Uc73KX/fu3dm4caNP2YYNG+jZs2e1++nbty/Z2dl06tSJLl26+DwCtZ5McFhQqopEo+K8PSdOhGb4dyAZGRlkZGSEuhqmgbnsssuIi4vjoYceYteuXSxevJhXX33VZ51p06axbNkydu3aRXZ2Nu+99x6pqalERUURExNDu3btWLNmDd98802VAWXp0qWMHTuWlStXkpeXR25uLn/84x9Zu3Ytw4YNA2DMmDE0bdqUG264gY0bN5Kfn8+7777L+vXrAZg8eTKvvfYas2fPJi8vj6effpolS5YwZcqUao+xooU3evRotmzZQn5+Pn/961+5/fbbKS0trYN30dSIqkbko1+/fnq6ig8Va/4nuVq4p1QLC1Vzc1WPHj3tzdWpoqIiLSoqCnU1GrwdO3aEugpnZMmSJer8+fvKyclRQLdv315p2VtvvaUXXHCBxsfH69VXX61z585VQA8fPqyqqtOnT9fu3btrQkKCnnPOOXrdddfpF1984Xn922+/rZ07d9aYmBhNTU0NWK+dO3fqr3/9a+3WrZsmJiZq8+bNtU+fPvrcc8/5rFdQUKDDhw/XZs2aaWJiovbr1083bNjgWf7ss89qp06dNDY2Vrt27apz5871LCspKVFAly9fHvD409PTtXnz5pqQkKCpqal6zz336PHjx6t/Q88y1X1+gU80hP+7Rf36iSNF//799ZNPPjmt15YcLmFf3tfEJ3eGqGiOHIELLoDo6DqupDlr5eTk0KNHj1BXw5jTUt3nV0S2qmrtR7rUEeu+q4pEgURRXu6MvAuXgPTOO+/wzjvvhLoaxhgTFDYkvApKDD8WC+XlobtRNpBnn30WgF/+8pchrokxxtQ9C0pVKD0RS5N4SE4On1YSwPvvvx/qKhhjTNBYUKpCbFwMycnQqFGoa+KreUWuDGOMiUB2TSmA6Jhozk2JD7uABLB48WIWL14c6moYqHQzqTFng3D/3FpLKYC4hDjiEsLkxiQ/FbMujxw5MsQ1adhiY2MpKSkhMTEx1FUxplZKSkrqLRXJ6ajXlpKIpInIFyKyS0SmBlh+voh8KCKficg2Ebnaa1lvEdkkItkisl1EwmSOhfq1cuVKVq5cGepqNHjJyckUFhZSXFwc9t88jQGnhVRcXExhYSHJycmhrk6V6q2lJCLRwAvAVcDXwBYRWaaqO7xWexh4S1VfEpGewEqgo4jEAG8At6rqP0XkXKCMBsi+mYeHZs2aAU5SOv854IwJV7GxsaSkpHg+v+GoPrvvLgZ2qWo+gIgsAtIB76CkQMW71RzY6/7+X8A2Vf0ngKp+Xy81DkNvvPEGALfcckuIa2KaNWsW1n/cxpyN6rP7ri2wx+v5126Zt0eBW0Tka5xW0t1ueTdAReQvIvKpiAScxEpExovIJyLySaRmi5wzZw5z5swJdTWMMSYowm2gw03APFXNEJFLgQUi0gunngOA/wSKgbXuVBhrvV+sqrOB2eBMM1S/Va8fq1evDnUVjDEmaOqzpVQItPd63s4t83Y78BaAqm4C4oEknFZVpqp+p6rFOK2ovkGvcRiKjY0N65EzxhhzJuozKG0BuopIJxGJA0YBy/zW+RcwBEBEeuAEpSLgL8B/iEiiO+jhSnyvRTUY8+bNY968eaGuhjHGBEW9dd+p6nERuQsnwEQDr6tqtog8hjNV+jJgEvCqiNyPM+jhNncq9QMi8jROYFNgpar+ub7qHk4qAtJtt90W0noYY0wwRGzqChEpAnafwSaSgO/qqDpnCzvmhsGOueE4nePuoKqtglGZmojYoHSmROSTUOYUCQU75obBjrnhOBuP2+a+M8YYEzYsKBljjAkbFpSqNjvUFQgBO+aGwY654TjrjtuuKRljjAkb1lIyxhgTNiwoGWOMCRsWlPycKudTJBCR9m7eqh1ufqp73fJzRGS1iOS5P1uGuq51TUSi3XxdK9znnUTkI/d8L3ZnG4koItJCRN4WkVwRyRGRSyP9XIvI/e5n+3MRWSgi8ZF2rkXkdRHZLyKfe5UFPK/ieNY99m0iErbTtFlQ8uKV8+kXQE/gJjevU6Q5DkxS1Z7AT4EJ7nFOBdaqaldgrfs80twL5Hg9/xMwU1W7AAdw5l+MNM8Aq1S1O3AhzvFH7LkWkbbAPUB/Ve2FM4PMKCLvXM8D0vzKqjqvvwC6uo/xwEv1VMdas6Dky5PzSVVLgYqcTxFFVfep6qfu74dx/km1xTnW+e5q84EbQlPD4BCRdsA1wBz3uQCDgbfdVSLxmJsDVwCvAahqqaoeJMLPNc4UagnuXJmJwD4i7Fyraibwb7/iqs5rOvC/6tgMtBCR8+qnprVjQclXTXI+RRQR6Qj0AT4CUlR1n7voGyAlRNUKllnAFKDcfX4ucFBVj7vPI/F8d8KZ1Hiu2205R0QaE8HnWlULgRk4EzzvA34AthL55xqqPq9nzf82C0oNmIg0AZYC96nqIe9l7kS4EXO/gIhcC+xX1a2hrks9i8FJ8/KSqvYBfsSvqy4Cz3VLnJZBJ6AN0JjK3VwR72w9rxaUfNUk51NEEJFYnID0pqq+4xZ/W9Gkd3/uD1X9guBy4HoR+QqnW3YwzrWWFm4XD0Tm+f4a+FpVP3Kfv40TpCL5XA8FClS1SFXLgHdwzn+kn2uo+ryeNf/bLCj5qknOp7Oeey3lNSBHVZ/2WrQMGOv+PhZ4v77rFiyq+pCqtlPVjjjn9W+qejPwIfArd7WIOmYAVf0G2CMiqW7REJxcZBF7rnG67X7q5l8TTh5zRJ9rV1XndRkwxh2F91PgB69uvrBiMzr4EZGrca49VOR8+kOIq1TnRGQAsB7YzsnrK9Nwriu9BZyPk/ZjhKr6X0g964nIIOABVb1WRDrjtJzOAT4DblHVY6GsX10TkYtwBnfEAfnAf+N8IY3Ycy0ivwdG4ow0/Qz4Nc41lIg51yKyEBiEk57iW+AR4D0CnFc3OD+P041ZDPy3qn4SinqfigUlY4wxYcO674wxxoQNC0rGGGPChgUlY4wxYcOCkjHGmLBhQckYY0zYsKBkzFlMRDqKiIpI/0DPjTnbWFAyDYqIzHP/aauIlIlIvojMcOeDC2si8ncRed6veA9wHpAVgioZU+diTr2KMRFnDXArEAsMxLmxtDFwZ203JCJx7ozyIaGq1OC7TgAAAmxJREFUJ3Am3jQmIlhLyTREx1T1G1Xdo6r/B7yJO8W/iPQUkT+LyGE3gdpCEWld8UK3pbVCRB4Uka9x5pZDROJE5EkR2S0ix9wW2D1er6vpdu8VkUIROSAic0UksWI5cCVO7quKll7HmnTXnWrfxoQTC0rGQAkQ605gmQl8jpNbayjQBHhfRLz/Vq4EeuNM2TLELZsPjAEmAj1wEsgdBM/EmDXZ7kCgl7t8JDAMJykh7s9NwFyc7rrz8E1FEFAt9m1MWLDuO9OgicjFwGicLJ13Av9U1Qe9lo/BSaTWH/jYLT4KjKuYN01EuuJM8voLVV3lrpPvtZuabvcQ8Bu3Sy5HRJbgBL0/quoPIlIKFLuTrFZs51SHWNN9GxMW7JuSaYjSROSIiBzFaX1kAncD/YAr3GVHROQIJ1sjF3i9/nO/iTz74Exs+2EV+6vpdne4AanCXiD5dA7wNPZtTFiwlpJpiDKB8UAZsNfNuYPbnfVn4IEAr/nW6/cfa7m/mm63zG+ZcuZfHGu6b2PCggUl0xAVq+quAOWfAiOA3RWBqoaycP75/wxYFWD56W7XXylOSpXaqKt9G1MvrPvOmJNeAJoDi0XkEhHpLCJDRWS2iDSt6kWquhMnh80cERnuJokcKCK3nsl2A/gKuNgdcZdUw4EKdbVvY+qFBSVjXKq6FydtdjlOiycb55/6MfdRnTHA/wHPArnAPJxgcKbb9TYDp7W0AyjCSeQWzGMypt5Zkj9jjDFhw1pKxhhjwoYFJWOMMWHDgpIxxpiwYUHJGGNM2LCgZIwxJmxYUDLGGBM2LCgZY4wJGxaUjDHGhI3/B1x82ewn6plfAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run_precision_plt(X, y, nfolds, percentiles, run_lr, plt_title=plt_title, \n",
    "                  plt_names=plt_names, predict_correct=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detect incorrectly classified examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By taking the *negative of the prediction probabilities and trust scores*, we can also see on the plot below how the trust scores compare to the model predictions for incorrectly classified instances. The vertical dotted line is the accuracy of the logistic regression classifier. The plot shows the precision of identifying incorrectly classified instances. Higher is obviously better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "percentiles = [50 + 0.5 * i for i in range(100)]\n",
    "plt_title = 'Iris -- Logistic Regression -- Predict Incorrect'\n",
    "run_precision_plt(X, y, nfolds, percentiles, run_lr, plt_title=plt_title, \n",
    "                  plt_names=plt_names, predict_correct=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
